\section{Zufallszahlentests}
\label{sec_tests}

Mit Hilfe von verschiedenen Betriebssystemen, verschiedener Programmiersprachen
und dem Programm Prngd sollten jeweils eine Menge von Zufallsbits erzeugt und
mit der Nist-Testsuite getestet werden. Dabei wurden immer mindestens 1 Million
Bits erzeugt und binär in eine Datei geschrieben. Bei der Überprüfung der Zufallsbits 
durch die implementierte Nist-Testsuite (siehe  Kap. \ref{sec_nist}) wurden immer 1 Mio Bits geprüft.
Damit bestehen für alle zu prüfenden Quellen von Zufallszahlen die gleichen
Testbedingungen. In den folgenden Abschnitten wird kurz auf die Erzeugung der
Zufallszahlen eingegangen und die Ergebnisse der Nist-Testsuite in einer Tabelle
festgehalten.

\newpage
\subsection{Rand() in C}
\label{subsec:rand}
Um Zufallsbits der Funktion \textbf{rand()} aus C zu untersuchen, wurde ein
kleines Hilfeprogramm \textbf{pk14\_random} erstellt. Mit Hilfe dieses kleinen
Programms werden Zufallszahlen duch \textbf{rand()} erzeugt und binär in eine
Ausgabedatei geschrieben. Um 1 Million Zufallsbits zu erzeugen, wird das
Programm mit folgenden Parametern gestartet:

\begin{description}
\item[./pk14\_random -rand 1000000 C:/output]
\end{description}

Es werden also 1 Million Zufallsbits von \textbf{rand()} erzeugt und in die
Datei "`ouput"' im Pfad "`C:/" geschrieben. 

\begin{table}[h]
    \centering 
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &      0.149302     &      passed     \\
    \hline
    Frequency within a Block    & 0.142743  & passed  \\
    \hline
    Runs        &      0.751213     &      passed     \\
    \hline
    Longest Run of Ones in a Block  & 0.695832  & passed \\
    \hline
    Binary Matrix Rank  & 0.63242  &  passed  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.0923577 & passed \\
    \hline
    Linear Complexity & 0.623037 & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits aus rand() in C unter OpenSuse}
    \label{tabel:testcrand}
\end{table}
\newpage

\subsection{lrand48 in C}
Ähnlich wie bei der Erzeugung von Zufallsbits durch \textbf{rand()} (siehe Kap.
\ref{subsec:rand}) wird das Programm \textbf{pk14\_random} genutzt. Hierbei sind
die Eingabeparameter wie folgt:

\begin{description}
\item[./pk14\_random -lrand48 1000000 C:/output]
\end{description} 


\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &      \(4.88291 * 10^-232\)     &      FAIL     \\
    \hline
    Frequency within a Block    & \(1.14378 * 10^-14\)  & FAIL  \\
    \hline
    Runs        &    0       &      FAIL     \\
    \hline
    Longest Run of Ones in a Block  &  \(8.74843*10^-9\)  &  FAIL \\
    \hline
    Binary Matrix Rank  & \(3.74357*10^-182\)  & FAIL  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.00790933 & FAIL\\
    \hline
    Linear Complexity & 0.551783 & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits aus lrand48() unter OpenSuse}
    \label{tabel:testclrand48}
\end{table}

\newpage
\subsection{OFD Chiffren von Openssl}
\label{subsec:openssl}
Für die Generierung von Zufallsbits mittels Openssl wurden unter OpenSuse
folgende Befehle verwendet:
\begin{description}
\item[dd if=/dev/zero of=zero count=125000 bs=1]
\item[openssl enc -aes-128-ofb -pass pass:00000000 <zero >aes-128-ofb]
\end{description}

Dadurch wurden 1 Millionen Bits erzeugt und in die Datei "`aes-128-ofb"'
geschrieben.
\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &     0.233261     &      passed     \\
    \hline
    Frequency within a Block    &  0.747804  & passed  \\
    \hline
    Runs        &    0.971849     &      passed      \\
    \hline
    Longest Run of Ones in a Block  &  0.0234216  &  passed \\
    \hline
    Binary Matrix Rank  & 0.444772 & passed  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.705155  & passed\\
    \hline
    Linear Complexity & 0.967423 & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline 
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits aus Openssl}
    \label{tabel:testopenssl}
\end{table}


\newpage
\subsection{/dev/random auf FreeBSD}
Um die Zufallsbits aus "`/dev/random"' auf FreeBSD zu lesen und in eine Datei zu
schreiben wurde das Programm \textbf{dd} wie folgt verwendet.
\begin{description}
\item[dd if=/dev/random of=/unserpfad/dateiname bs=1 count=125000]
\end{description}
Dabei werden 125000 Byte (1 Mio Bit) aus der Datei "`/dev/random"' in unsere
unter \textbf{of=} angegebene Datei kopiert.

\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &    0.353408       &     passed      \\
    \hline
    Frequency within a Block    & 0.311947  &  passed \\
    \hline
    Runs        &       0.785184    &    passed       \\
    \hline
    Longest Run of Ones in a Block  & 0.128711  & passed \\
    \hline
    Binary Matrix Rank  &  0.000407242 & FAIL  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.56295  & passed \\
    \hline
    Linear Complexity & 0.150598 & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits aus FreeBSD /dev/random}
    \label{tabel:testbsd}
\end{table}



\newpage
\subsection{/dev/random auf OpenSuse}
Um die Zufallsbits aus "`/dev/random"' auf OpenSuse zu lesen und in eine Datei
zu schreiben wurde das Programm \textbf{dd} wie folgt verwendet.
\begin{description}
\item[dd if=/dev/random of=/unserpfad/dateiname bs=1 count=125000]
\end{description}
Dabei werden 125000 Byte (1 Mio Bit) aus der Datei "`/dev/random"' in unsere
unter \textbf{of=} angegebene Datei kopiert.

\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &     0.0929573      &       passed    \\
    \hline
    Frequency within a Block    &  0.174769  &  passed  \\
    \hline
    Runs        &      0.949439     &        passed   \\
    \hline
    Longest Run of Ones in a Block  & 0.417156  & passed \\
    \hline
    Binary Matrix Rank  &  0.833807 & passed  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.139642 & passed \\
    \hline
    Linear Complexity & 0.852491  & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits aus OpenSuse /dev/random}
    \label{tabel:testbsd}
\end{table}

\newpage
\subsection{/dev/random auf Solaris}
Um die Zufallsbits aus "`/dev/random"' auf Solaris zu lesen und in eine Datei zu
schreiben wurde das Programm \textbf{dd} wie folgt verwendet.
\begin{description}
\item[dd if=/dev/random of=/unserpfad/dateiname bs=1 count=125000]
\end{description}
Dabei werden 125000 Byte (1 Mio Bit) aus der Datei "`/dev/random"' in unsere
unter \textbf{of=} angegebene Datei kopiert.

\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &     0.739889      &      passed     \\
    \hline
    Frequency within a Block    & 0.702365  &  passed  \\
    \hline
    Runs        &      0.868901     &      passed     \\
    \hline
    Longest Run of Ones in a Block  & 0.297244  &  passed \\
    \hline
    Binary Matrix Rank  & 0.672164  &  passed  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical &  0.0407018 & passed \\
    \hline
    Linear Complexity & 0.710174 & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits aus Solaris /dev/random}
    \label{tabel:testbsd}
\end{table}

\newpage
\subsection{Python}
Um die Zufallsbits in Python zu erzeugen wurde Python v3.4 auf einem
Windows-Rechner installiert. Mit Hilfe von Python IDLE wurden folgende Befehle
eingegeben:

\lstset{caption={Erzeugung von Zufallsbits mit Python}, label=lst:python,
language=python}
    \begin{lstlisting}
    import pickle
    import random
    with open('pyrnd','wb') as f:
    pickle.dump(random.getrandbits(1000000),f,pickle.HIGHEST_PROTOCOL)
    \end{lstlisting}
     
Durch die Verwendung von \textbf{open} wird eine Datei, mit dem Namen
"`pyrnd", im Installationsverzeichnis geöffnet in die wir hineinschreiben
können, \textbf{f} ist dabei unser erhaltener Filedeskriptor auf die Datei. Mittels
\textbf{random.getrandbits(100000)} benutzen wir die Klasse "`Random"' von
Python um 1 Mio Zufallsbits zu erzeugen. Um diese binär in unsere geöffnete
Datei schreiben zu können, wird die Klasse "`Pickle"' verwendet, welche zur
Serialisierung von Daten in Python zuständig ist.


\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &      0.116415     &      passed     \\
    \hline
    Frequency within a Block    &  0.270307 &  passed  \\
    \hline
    Runs        &      0.453394     &     passed      \\
    \hline
    Longest Run of Ones in a Block  &  0.0995282 & passed \\
    \hline
    Binary Matrix Rank  & 0.331643  & passed  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.228228 & passed \\
    \hline
    Linear Complexity & 0.640761 & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits mittels Python}
    \label{tabel:testbsd}
\end{table}

\newpage
\subsection{Ruby}
Zufallsbits mit Ruby zu erzeugen war ähnlich einfach wie mit Python. Zunächst
wurde Ruby v2.1.2 auf einem Windows-Rechner installiert. Über
das mitgelieferte Programm "`Interactive Ruby"' wurden folgende
Befehle eingegeben.

\lstset{caption={Erzeugung von Zufallsbits mit Ruby}, label=lst:ruby,
language=ruby}
    \begin{lstlisting}
    f=File.new("rubyrnd","w")
    f.write(Random.new.bytes(125000))
    f.close
    \end{lstlisting}
    
Der Code ist weitestgehend selbsterklärend, es wird die Klasse \textbf{File} zum
schreiben in eine Datei verwendet und die Klasse\textbf{Random} zum erzeugen von
Zufallsbytes.


\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &      0.752003     &     passed      \\
    \hline
    Frequency within a Block    & 0.216559  & passed  \\
    \hline
    Runs        &      0.620635     &      passed     \\
    \hline
    Longest Run of Ones in a Block  &  0.0122031 & passed \\
    \hline
    Binary Matrix Rank  & 0.728665  &  passed  \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.389471 &  passed \\
    \hline
    Linear Complexity & 0.593064 &  passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits mittels Ruby}
    \label{tabel:testbsd}
\end{table}

\newpage
\subsection{BBS von Prngd}


\begin{table}[h]
    \centering
    \begin{tabular}{|c|c|c|}
    \hline
    \textbf{Testname}    &  \textbf{P-Value} &   \textbf{Ergebnis} \\
    \hline
    Monobit     &      0.552512     &      passed     \\
    \hline
    Frequency within a Block    &  0.831639  &  passed \\
    \hline
    Runs        &      0.821842    &       passed    \\
    \hline
    Longest Run of Ones in a Block  & 0.527207  & passed \\
    \hline
    Binary Matrix Rank  & 0.648491  &  passed \\
    \hline
    Discrete Fourier Transform & & \\
    \hline
    Non-overlapping Template Matching & & \\
    \hline
    Overlapping Template Matching & & \\
    \hline
    Maurer's Universal Statistical & 0.852522  &  passed \\
    \hline
    Linear Complexity & 0.234613  & passed \\
    \hline
    Serial & & \\
    \hline
    Approximate Entropy & & \\
    \hline
    Cumulative Sums & & \\
    \hline
    Random Excursions & & \\
    \hline
    Random Excursions Variant & & \\
    \hline
    \end{tabular}
    \caption{Testergebnisse für Zufallsbits mittels BBS von Prngd}
    \label{tabel:testbbs}
\end{table}
